home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 3006 / 3006.xpi / components / dhSafeModeHandler.js < prev    next >
Encoding:
Text File  |  2010-01-15  |  11.2 KB  |  354 lines
  1. /******************************************************************************
  2.  *            Copyright (c) 2006-2009 Michel Gutierrez. All Rights Reserved.
  3.  ******************************************************************************/
  4.  
  5. /**
  6.  * Constants.
  7.  */
  8.  
  9. const NS_SAFE_MODE_HANDLER_CID = Components.ID("{cbcb1770-ec4c-404c-9a3f-b8e1c49859d0}");
  10. const NS_SAFE_MODE_HANDLER_PROG_ID = "@downloadhelper.net/safe-mode-handler;1";
  11. const DHNS = "http://downloadhelper.net/1.0#";
  12.  
  13. var Util=null;
  14.  
  15. /**
  16. * Object constructor
  17. */
  18. function SafeModeHandler() {
  19.     //dump("[SafeModeHandler] constructor\n");
  20.     var prefService=Components.classes["@mozilla.org/preferences-service;1"]
  21.                                        .getService(Components.interfaces.nsIPrefService);
  22.     this.pref=prefService.getBranch("dwhelper.");
  23.     var uriLoader = Components.classes["@mozilla.org/uriloader;1"].getService(Components.interfaces.nsIURILoader);
  24.     uriLoader.registerContentListener(this);
  25.     this.updateMode();
  26. }
  27.  
  28. SafeModeHandler.prototype = {
  29.         get loadCookie() { return this.mLoadCookie; },
  30.         set loadCookie(newval) { return this.mLoadCookie=newval; },
  31.         get parentContentListener() { return this.mParentContentListener; },
  32.         set parentContentListener(newval) { return this.mParentContentListener=newval; }
  33. }
  34.  
  35. SafeModeHandler.prototype.updateMode = function() {
  36.     var safe=false;
  37.     try {
  38.         safe=this.pref.getBoolPref("safe-mode");
  39.     } catch(e) {}
  40.     if(!safe) {
  41.         var ios = Components.classes["@mozilla.org/network/io-service;1"]
  42.                                      .getService(Components.interfaces.nsIIOService);
  43.         var uri = ios.newURI("http://www.downloadhelper.net/", null, null);
  44.         var cookieSvc =
  45.             Components.classes["@mozilla.org/cookieService;1"]
  46.                                .getService(Components.interfaces.nsICookieService);
  47.         var cookieStr = cookieSvc.getCookieString(uri, null);
  48.         if(cookieStr!=null) {
  49.             var cookies=cookieStr.split(";");
  50.             for(var i=0;i<cookies.length;i++) {
  51.                 if(/^ *(.*?) *$/.exec(cookies[i])[1]=="sa0=1") {
  52.                     safe=true;
  53.                     break;
  54.                 }
  55.             }
  56.         }
  57.     }
  58.     this.setMode(safe);
  59. }
  60.  
  61. SafeModeHandler.prototype.setMode = function(safe) {
  62.     this.setCookies(safe);
  63.     this.pref.setBoolPref("safe-mode",safe);
  64. }
  65.  
  66. SafeModeHandler.prototype.setCookies = function(safe) {
  67.     try {
  68.         var cMgr = Components.classes["@mozilla.org/cookiemanager;1"].
  69.            getService(Components.interfaces.nsICookieManager2);
  70.         var cname="saf";
  71.         if(safe) {
  72.             var cookieDate=new Date().getTime()/1000+60*60*24*365*18;
  73.             var cvalue="1";
  74.             try {
  75.                 cMgr.add(".downloadhelper.net","/",cname,""+cvalue,false,true,cookieDate);
  76.                 cMgr.add(".vidohe.com","/",cname,""+cvalue,false,true,cookieDate);
  77.             } catch(e) {
  78.                 cMgr.add(".downloadhelper.net","/",cname,""+cvalue,false,true,false,cookieDate);
  79.                 cMgr.add(".vidohe.com","/",cname,""+cvalue,false,true,false,cookieDate);
  80.             }
  81.         } else {
  82.             cMgr.remove(".www.downloadhelper.net",cname,"/",false);
  83.             cMgr.remove(".www.vidohe.com",cname,"/",false);
  84.             cMgr.remove(".downloadhelper.net",cname,"/",false);
  85.             cMgr.remove(".vidohe.com",cname,"/",false);
  86.         }
  87.     } catch(e) {
  88.         dump("[SafeModeHandler] setMode("+safe+") error: "+e+"\n");    
  89.     }
  90. }
  91.  
  92. SafeModeHandler.prototype.canHandleContent = function( 
  93.     contentType, 
  94.     isContentPreferred, 
  95.     desiredContentType )  {
  96.  
  97.     //dump("[SafeModeHandler] canHandleContent contentType: "+contentType+"\n");
  98.  
  99.     if(contentType=="application/x-downloadhelper-safe-mode") 
  100.         return true;
  101.     else
  102.         return false;
  103.     
  104. }
  105.  
  106. SafeModeHandler.prototype.doContent = function( 
  107.     contentType , 
  108.     isContentPreferred , 
  109.     request , 
  110.     contentHandler ) {
  111.     
  112.     //dump("[SafeModeHandler] doContent contentType: "+contentType+"\n");
  113.  
  114.     if(contentType!="application/x-downloadhelper-safe-mode")
  115.         return false;
  116.         
  117.     function StreamListener(service) {
  118.         this.service=service;
  119.     }
  120.  
  121.     StreamListener.prototype={
  122.         QueryInterface: function(iid) {
  123.             if (!iid.equals(Components.interfaces.nsISupports) && 
  124.                 !iid.equals(Components.interfaces.nsIStreamListener)) {
  125.                     throw Components.results.NS_ERROR_NO_INTERFACE;
  126.                 }
  127.             return this;
  128.         },
  129.         onStartRequest: function(request,context) {
  130.  
  131.             try {
  132.  
  133.             this.httpChannel=request.QueryInterface(Components.interfaces.nsIHttpChannel);
  134.             this.responseStatus=this.httpChannel.responseStatus;
  135.             this.responseStatusText=this.httpChannel.responseStatusText;
  136.             this.contentType=this.httpChannel.getResponseHeader("content-type");            
  137.             this.data="";
  138.             
  139.             //dump("[SafeModeHandler/StreamListener] onStartRequest response: "+
  140.             //    this.responseStatus+" "+this.responseStatusText+"\n");
  141.  
  142.             } catch(e) {
  143.                 dump("[SafeModeHandler/StreamListener] onStartRequest error: "+e+"\n");    
  144.             }
  145.  
  146.         },
  147.         onDataAvailable: function(request,context,inputStream,offset,count) {
  148.             //dump("[SafeModeHandler/StreamListener] onDataAvailable\n");    
  149.  
  150.             try {
  151.             
  152.             var sstream = Components.classes["@mozilla.org/intl/converter-input-stream;1"]
  153.                    .createInstance(Components.interfaces.nsIConverterInputStream);
  154.             sstream.init(inputStream, "utf-8", 256, 
  155.                 Components.interfaces.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
  156.  
  157.             var str={};
  158.             var n=sstream.readString(128,str);
  159.             while(n>0) {
  160.                 this.data+=str.value;
  161.                 //dump("[SafeModeHandler/StreamListener] onDataAvailable read: "+str.value+"\n");    
  162.                 str={};
  163.                 n=sstream.readString(128,str);
  164.             }
  165.  
  166.             } catch(e) {
  167.                 dump("[SafeModeHandler/StreamListener] onDataAvailable error: "+e+"\n");    
  168.             }
  169.  
  170.         },
  171.         onStopRequest: function(request,context,nsresult) {
  172.             //dump("[SafeModeHandler/StreamListener] onStopRequest\n");
  173.  
  174.             try {
  175.  
  176.             if(this.responseStatus==200) {
  177.  
  178.                 //dump("[SafeModeHandler/StreamListener] parsing data: "+this.data+"\n");            
  179.                     
  180.                 var parser=Components.classes["@mozilla.org/xmlextras/domparser;1"].
  181.                     createInstance(Components.interfaces.nsIDOMParser);
  182.                 var doc=parser.parseFromString(this.data,"text/xml");
  183.                 if(doc!=null) {
  184.                     var mode=Util.xpGetString(doc.documentElement,"/safe-mode/mode");
  185.                     if(mode!="false") {
  186.                         mode=true;
  187.                     } else {
  188.                         mode=false;
  189.                     }
  190.                     var promptService=Components.classes["@mozilla.org/embedcomp/prompt-service;1"]
  191.                                                           .getService(Components.interfaces.nsIPromptService);
  192.                     var currentMode=this.service.pref.getBoolPref("safe-mode");
  193.                     if(currentMode==mode) {
  194.                         promptService.alert(null,Util.getText("title.safe-mode-handler"),Util.getText("message.safe-mode-unchanged"));
  195.                     } else {
  196.                         if(mode) {
  197.                             if(promptService.confirm(null,Util.getText("title.safe-mode-handler"),Util.getText("message.confirm-safe-mode-in")))
  198.                                 this.service.setMode(true);
  199.                         } else {
  200.                             if(promptService.confirm(null,Util.getText("title.safe-mode-handler"),Util.getText("message.confirm-safe-mode-out")))
  201.                                     this.service.setMode(false);
  202.                         }
  203.                     }
  204.                 } else {
  205.                     dump("[SafeModeHandler/StreamListener] invalid safe-mode file: "+this.data+"\n");
  206.                 }
  207.             }
  208.             
  209.             } catch(e) {
  210.                 dump("[SafeModeHandler/StreamListener] onStopRequest error: "+e+"\n");
  211.             }
  212.  
  213.         }
  214.     }
  215.     
  216.     try {
  217.         contentHandler.value=new StreamListener(this);
  218.     } catch(e) {
  219.         dump("[SafeModeHandler] openAsync error: "+e+"\n");    
  220.     }
  221.         
  222.     return false;
  223. }
  224.  
  225. SafeModeHandler.prototype.isPreferred = function( 
  226.     contentType , 
  227.     desiredContentType ) {
  228.  
  229.     //dump("[SafeModeHandler] isPreferred contentType: "+contentType+"\n");
  230.  
  231.     if(contentType=="application/x-downloadhelper-safe-mode") 
  232.         return true;
  233.     else
  234.         return false;
  235.  
  236. }
  237.  
  238.  
  239. SafeModeHandler.prototype.onStartURIOpen = function( URI ) {
  240.  
  241.     //dump("[SafeModeHandler] onStartURIOpen: "+URI.spec+"\n");
  242.  
  243.     return false;
  244. }
  245.  
  246. SafeModeHandler.prototype.GetWeakReference = function( ) {
  247.  
  248.     //dump("[SafeModeHandler] GetWeakReference\n");
  249.  
  250.     return this;
  251. }
  252.  
  253.  
  254. SafeModeHandler.prototype.QueryInterface = function(iid) {
  255.     //dump("[SafeModeHandler] QueryInterface("+iid+")\n");
  256.     if(
  257.         iid.equals(Components.interfaces.nsISupports)==false &&
  258.         !iid.equals(Components.interfaces.nsIURIContentListener) &&
  259.         !iid.equals(Components.interfaces.nsISupportsWeakReference)
  260.     ) {
  261.             throw Components.results.NS_ERROR_NO_INTERFACE;
  262.         }
  263.     return this;
  264. }
  265.  
  266. var vSafeModeHandlerModule = {
  267.     firstTime: true,
  268.     
  269.     /*
  270.      * RegisterSelf is called at registration time (component installation
  271.      * or the only-until-release startup autoregistration) and is responsible
  272.      * for notifying the component manager of all components implemented in
  273.      * this module.  The fileSpec, location and type parameters are mostly
  274.      * opaque, and should be passed on to the registerComponent call
  275.      * unmolested.
  276.      */
  277.     registerSelf: function (compMgr, fileSpec, location, type) {
  278.  
  279.         if (this.firstTime) {
  280.             this.firstTime = false;
  281.             throw Components.results.NS_ERROR_FACTORY_REGISTER_AGAIN;
  282.         }
  283.         compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  284.         compMgr.registerFactoryLocation(NS_SAFE_MODE_HANDLER_CID,
  285.                                         "SafeModeHandler",
  286.                                         NS_SAFE_MODE_HANDLER_PROG_ID, 
  287.                                         fileSpec,
  288.                                         location,
  289.                                         type);
  290.     },
  291.  
  292.     unregisterSelf: function(compMgr, fileSpec, location) {
  293.         compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
  294.         compMgr.unregisterFactoryLocation(NS_DH_SAFE_MODE_HANDLER_CID, fileSpec);
  295.     },
  296.  
  297.     /*
  298.      * The GetClassObject method is responsible for producing Factory and
  299.      * SingletonFactory objects (the latter are specialized for services).
  300.      */
  301.     getClassObject: function (compMgr, cid, iid) {
  302.         if (!cid.equals(NS_SAFE_MODE_HANDLER_CID)) {
  303.             throw Components.results.NS_ERROR_NO_INTERFACE;
  304.         }
  305.  
  306.         if (!iid.equals(Components.interfaces.nsIFactory)) {
  307.             throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  308.         }
  309.  
  310.         return this.vSafeModeHandlerFactory;
  311.     },
  312.  
  313.     /* factory object */
  314.     vSafeModeHandlerFactory: {
  315.         /*
  316.          * Construct an instance of the interface specified by iid, possibly
  317.          * aggregating it with the provided outer.  (If you don't know what
  318.          * aggregation is all about, you don't need to.  It reduces even the
  319.          * mightiest of XPCOM warriors to snivelling cowards.)
  320.          */
  321.         createInstance: function (outer, iid) {
  322.             if (outer != null) {
  323.                 throw Components.results.NS_ERROR_NO_AGGREGATION;
  324.             }
  325.     
  326.             if(Util==null) 
  327.                 Util=Components.classes["@downloadhelper.net/util-service;1"]
  328.                     .getService(Components.interfaces.dhIUtilService);
  329.  
  330.             return new SafeModeHandler().QueryInterface(iid);
  331.         }
  332.     },
  333.  
  334.     /*
  335.      * The canUnload method signals that the component is about to be unloaded.
  336.      * C++ components can return false to indicate that they don't wish to be
  337.      * unloaded, but the return value from JS components' canUnload is ignored:
  338.      * mark-and-sweep will keep everything around until it's no longer in use,
  339.      * making unconditional ``unload'' safe.
  340.      *
  341.      * You still need to provide a (likely useless) canUnload method, though:
  342.      * it's part of the nsIModule interface contract, and the JS loader _will_
  343.      * call it.
  344.      */
  345.     canUnload: function(compMgr) {
  346.         return true;
  347.     }
  348. };
  349.  
  350. function NSGetModule(compMgr, fileSpec) {
  351.     return vSafeModeHandlerModule;
  352. }
  353.  
  354.